1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
 
2
 
 
 
2
 
2
 
 
 
 
 
 
 
1
2
 
 
 
 
 
2
 
 
2
 
 
2
2
 
1
 
 
 
2
 
 
1
1
1
 
1
1
 
 
1
1
 
1
 
 
1
 
2
 
 
 
 
 
1
 
1
 
1
 
 
 
 
1
2
2
3
3
3
3
1
 
 
3
3
 
 
 
 
3
 
 
 
1
3
1
 
 
 
1
1
 
 
 
 
 
 
 
1
 
1
1
1
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1
 
 
 
 
 
 
 
 
 
 
 
1
 
 
6
6
 
1
 
2
 
1
 
2
 
 
 
 
1
1
 
1
 
 
 
 
1
 
 
 
 
 
 
1
 
 
1
1
 
 
1
1
 
1
1
1
1
1
1
1
 
1
1
 
1
 
 
 
 
/*
example.js
 
quickstart example
 
instruction
    1. save this script as example.js
    2. run the shell command:
        $ npm install npmtest-stylelint && PORT=8081 node example.js
    3. play with the browser-demo on http://127.0.0.1:8081
*/
 
 
 
/* istanbul instrument in package npmtest_stylelint */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - pre-init
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        // init utility2_rollup
        local = local.global.utility2_rollup || (local.modeJs === 'browser'
            ? local.global.utility2_npmtest_stylelint
            : global.utility2_moduleExports);
        // export local
        local.global.local = local;
    }());
    switch (local.modeJs) {
 
 
 
    // post-init
    // run browser js-env code - post-init
    /* istanbul ignore next */
    case 'browser':
        local.testRunBrowser = function (event) {
            Eif (!event || (event &&
                    event.currentTarget &&
                    event.currentTarget.className &&
                    event.currentTarget.className.includes &&
                    event.currentTarget.className.includes('onreset'))) {
                // reset output
                Array.from(
                    document.querySelectorAll('body > .resettable')
                ).forEach(function (element) {
                    switch (element.tagName) {
                    case 'INPUT':
                    case 'TEXTAREA':
                        element.value = '';
                        break;
                    default:
                        element.textContent = '';
                    }
                });
            }
            switch (event && event.currentTarget && event.currentTarget.id) {
            case 'testRunButton1':
                // show tests
                Eif (document.querySelector('#testReportDiv1').style.display === 'none') {
                    document.querySelector('#testReportDiv1').style.display = 'block';
                    document.querySelector('#testRunButton1').textContent =
                        'hide internal test';
                    local.modeTest = true;
                    local.testRunDefault(local);
                // hide tests
                } else {
                    document.querySelector('#testReportDiv1').style.display = 'none';
                    document.querySelector('#testRunButton1').textContent = 'run internal test';
                }
                break;
            // custom-case
            default:
                break;
            }
            Iif (document.querySelector('#inputTextareaEval1') && (!event || (event &&
                    event.currentTarget &&
                    event.currentTarget.className &&
                    event.currentTarget.className.includes &&
                    event.currentTarget.className.includes('oneval')))) {
                // try to eval input-code
                try {
                    /*jslint evil: true*/
                    eval(document.querySelector('#inputTextareaEval1').value);
                } catch (errorCaught) {
                    console.error(errorCaught);
                }
            }
        };
        // log stderr and stdout to #outputTextareaStdout1
        ['error', 'log'].forEach(function (key) {
            console[key + '_original'] = console[key];
            console[key] = function () {
                var element;
                console[key + '_original'].apply(console, arguments);
                element = document.querySelector('#outputTextareaStdout1');
                Iif (!element) {
                    return;
                }
                // append text to #outputTextareaStdout1
                element.value += Array.from(arguments).map(function (arg) {
                    return typeof arg === 'string'
                        ? arg
                        : JSON.stringify(arg, null, 4);
                }).join(' ') + '\n';
                // scroll textarea to bottom
                element.scrollTop = element.scrollHeight;
            };
        });
        // init event-handling
        ['change', 'click', 'keyup'].forEach(function (event) {
            Array.from(document.querySelectorAll('.on' + event)).forEach(function (element) {
                element.addEventListener(event, local.testRunBrowser);
            });
        });
        // run tests
        local.testRunBrowser();
        break;
 
 
 
    // run node js-env code - post-init
    /* istanbul ignore next */
    case 'node':
        // export local
        module.exports = local;
        // require modules
        local.fs = require('fs');
        local.http = require('http');
        local.url = require('url');
        // init assets
        local.assetsDict = local.assetsDict || {};
        /* jslint-ignore-begin */
        local.assetsDict['/assets.index.template.html'] = '\
<!doctype html>\n\
<html lang="en">\n\
<head>\n\
<meta charset="UTF-8">\n\
<meta name="viewport" content="width=device-width, initial-scale=1">\n\
<title>{{env.npm_package_name}} (v{{env.npm_package_version}})</title>\n\
<style>\n\
/*csslint\n\
    box-sizing: false,\n\
    universal-selector: false\n\
*/\n\
* {\n\
    box-sizing: border-box;\n\
}\n\
body {\n\
    background: #dde;\n\
    font-family: Arial, Helvetica, sans-serif;\n\
    margin: 2rem;\n\
}\n\
body > * {\n\
    margin-bottom: 1rem;\n\
}\n\
.utility2FooterDiv {\n\
    margin-top: 20px;\n\
    text-align: center;\n\
}\n\
</style>\n\
<style>\n\
/*csslint\n\
*/\n\
textarea {\n\
    font-family: monospace;\n\
    height: 10rem;\n\
    width: 100%;\n\
}\n\
textarea[readonly] {\n\
    background: #ddd;\n\
}\n\
</style>\n\
</head>\n\
<body>\n\
<!-- utility2-comment\n\
<div id="ajaxProgressDiv1" style="background: #d00; height: 2px; left: 0; margin: 0; padding: 0; position: fixed; top: 0; transition: background 0.5s, width 1.5s; width: 25%;"></div>\n\
utility2-comment -->\n\
<h1>\n\
<!-- utility2-comment\n\
    <a\n\
        {{#if env.npm_package_homepage}}\n\
        href="{{env.npm_package_homepage}}"\n\
        {{/if env.npm_package_homepage}}\n\
        target="_blank"\n\
    >\n\
utility2-comment -->\n\
        {{env.npm_package_name}} (v{{env.npm_package_version}})\n\
<!-- utility2-comment\n\
    </a>\n\
utility2-comment -->\n\
</h1>\n\
<h3>{{env.npm_package_description}}</h3>\n\
<!-- utility2-comment\n\
<h4><a download href="assets.app.js">download standalone app</a></h4>\n\
<button class="onclick onreset" id="testRunButton1">run internal test</button><br>\n\
<div id="testReportDiv1" style="display: none;"></div>\n\
utility2-comment -->\n\
\n\
\n\
\n\
<label>stderr and stdout</label>\n\
<textarea class="resettable" id="outputTextareaStdout1" readonly></textarea>\n\
<!-- utility2-comment\n\
{{#if isRollup}}\n\
<script src="assets.app.js"></script>\n\
{{#unless isRollup}}\n\
utility2-comment -->\n\
<script src="assets.utility2.rollup.js"></script>\n\
<script src="jsonp.utility2._stateInit?callback=window.utility2._stateInit"></script>\n\
<script src="assets.npmtest_stylelint.rollup.js"></script>\n\
<script src="assets.example.js"></script>\n\
<script src="assets.test.js"></script>\n\
<!-- utility2-comment\n\
{{/if isRollup}}\n\
utility2-comment -->\n\
<div class="utility2FooterDiv">\n\
    [ this app was created with\n\
    <a href="https://github.com/kaizhu256/node-utility2" target="_blank">utility2</a>\n\
    ]\n\
</div>\n\
</body>\n\
</html>\n\
';
        /* jslint-ignore-end */
        Iif (local.templateRender) {
            local.assetsDict['/'] = local.templateRender(
                local.assetsDict['/assets.index.template.html'],
                {
                    env: local.objectSetDefault(local.env, {
                        npm_package_description: 'the greatest app in the world!',
                        npm_package_name: 'my-app',
                        npm_package_nameAlias: 'my_app',
                        npm_package_version: '0.0.1'
                    })
                }
            );
        } else {
            local.assetsDict['/'] = local.assetsDict['/assets.index.template.html']
                .replace((/\{\{env\.(\w+?)\}\}/g), function (match0, match1) {
                    // jslint-hack
                    String(match0);
                    switch (match1) {
                    case 'npm_package_description':
                        return 'the greatest app in the world!';
                    case 'npm_package_name':
                        return 'my-app';
                    case 'npm_package_nameAlias':
                        return 'my_app';
                    case 'npm_package_version':
                        return '0.0.1';
                    }
                });
        }
        // run the cli
        Eif (local.global.utility2_rollup || module !== require.main) {
            break;
        }
        local.assetsDict['/assets.example.js'] =
            local.assetsDict['/assets.example.js'] ||
            local.fs.readFileSync(__filename, 'utf8');
        // bug-workaround - long $npm_package_buildCustomOrg
        /* jslint-ignore-begin */
        local.assetsDict['/assets.npmtest_stylelint.rollup.js'] =
            local.assetsDict['/assets.npmtest_stylelint.rollup.js'] ||
            local.fs.readFileSync(
                local.npmtest_stylelint.__dirname + '/lib.npmtest_stylelint.js',
                'utf8'
            ).replace((/^#!/), '//');
        /* jslint-ignore-end */
        local.assetsDict['/favicon.ico'] = local.assetsDict['/favicon.ico'] || '';
        // if $npm_config_timeout_exit exists,
        // then exit this process after $npm_config_timeout_exit ms
        if (Number(process.env.npm_config_timeout_exit)) {
            setTimeout(process.exit, Number(process.env.npm_config_timeout_exit));
        }
        // start server
        if (local.global.utility2_serverHttp1) {
            break;
        }
        process.env.PORT = process.env.PORT || '8081';
        console.error('server starting on port ' + process.env.PORT);
        local.http.createServer(function (request, response) {
            request.urlParsed = local.url.parse(request.url);
            if (local.assetsDict[request.urlParsed.pathname] !== undefined) {
                response.end(local.assetsDict[request.urlParsed.pathname]);
                return;
            }
            response.statusCode = 404;
            response.end();
        }).listen(process.env.PORT);
        break;
    }
}());
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
 
2
 
2
 
2
1
 
1
1
1
 
 
 
 
 
/* istanbul instrument in package npmtest_stylelint */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - pre-init
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        // init utility2_rollup
        local = local.global.utility2_rollup || local;
        // init lib
        local.local = local.npmtest_stylelint = local;
        // init exports
        if (local.modeJs === 'browser') {
            local.global.utility2_npmtest_stylelint = local;
        } else {
            module.exports = local;
            module.exports.__dirname = __dirname;
            module.exports.module = module;
        }
    }());
}());
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
2
 
 
1
 
 
 
1
 
 
1
 
1
 
 
2
 
 
 
 
 
2
2
 
2
 
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
 
2
2
 
2
 
 
 
 
 
1
 
 
 
 
 
 
1
 
 
 
1
 
 
1
 
 
 
 
 
 
1
 
 
 
 
 
 
1
1
 
 
1
 
 
 
 
 
 
1
1
1
1
1
1
 
 
1
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
1
1
 
 
 
1
1
 
 
 
 
/* istanbul instrument in package npmtest_stylelint */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - pre-init
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        switch (local.modeJs) {
        // re-init local from window.local
        case 'browser':
            local = local.global.utility2.objectSetDefault(
                local.global.utility2_rollup || local.global.local,
                local.global.utility2
            );
            break;
        // re-init local from example.js
        case 'node':
            local = (local.global.utility2_rollup || require('utility2'))
                .requireReadme();
            break;
        }
        // export local
        local.global.local = local;
    }());
 
 
 
    // run shared js-env code - function
    (function () {
        return;
    }());
    switch (local.modeJs) {
 
 
 
    // run browser js-env code - function
    case 'browser':
        break;
 
 
 
    // run node js-env code - function
    case 'node':
        break;
    }
 
 
 
    // run shared js-env code - post-init
    (function () {
        return;
    }());
    switch (local.modeJs) {
 
 
 
    // run browser js-env code - post-init
    case 'browser':
        local.testCase_browser_nullCase = local.testCase_browser_nullCase || function (
            options,
            onError
        ) {
        /*
         * this function will test browsers's null-case handling-behavior-behavior
         */
            onError(null, options);
        };
 
        // run tests
        local.nop(local.modeTest &&
            document.querySelector('#testRunButton1') &&
            document.querySelector('#testRunButton1').click());
        break;
 
 
 
    // run node js-env code - post-init
    /* istanbul ignore next */
    case 'node':
        local.testCase_buildApidoc_default = local.testCase_buildApidoc_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildApidoc's default handling-behavior-behavior
         */
            options = { modulePathList: module.paths };
            local.buildApidoc(options, onError);
        };
 
        local.testCase_buildApp_default = local.testCase_buildApp_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildApp's default handling-behavior-behavior
         */
            local.testCase_buildReadme_default(options, local.onErrorThrow);
            local.testCase_buildLib_default(options, local.onErrorThrow);
            local.testCase_buildTest_default(options, local.onErrorThrow);
            local.testCase_buildCustomOrg_default(options, local.onErrorThrow);
            options = [];
            local.buildApp(options, onError);
        };
 
        local.testCase_buildCustomOrg_default = local.testCase_buildCustomOrg_default ||
            function (options, onError) {
            /*
             * this function will test buildCustomOrg's default handling-behavior
             */
                options = {};
                local.buildCustomOrg(options, onError);
            };
 
        local.testCase_buildLib_default = local.testCase_buildLib_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildLib's default handling-behavior
         */
            options = {};
            local.buildLib(options, onError);
        };
 
        local.testCase_buildReadme_default = local.testCase_buildReadme_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildReadme's default handling-behavior-behavior
         */
            options = {};
            local.buildReadme(options, onError);
        };
 
        local.testCase_buildTest_default = local.testCase_buildTest_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildTest's default handling-behavior
         */
            options = {};
            local.buildTest(options, onError);
        };
 
        local.testCase_webpage_default = local.testCase_webpage_default || function (
            options,
            onError
        ) {
        /*
         * this function will test webpage's default handling-behavior
         */
            options = { modeCoverageMerge: true, url: local.serverLocalHost + '?modeTest=1' };
            local.browserTest(options, onError);
        };
 
        // run test-server
        local.testRunServer(local);
        break;
    }
}());
 
 

1
2
3
4
5
6
7
 
 
 
 
1
 
 
//#!/usr/bin/env node
 
"use strict"
 
require("../lib/cli")
 
 

1
2
3
4
5
6
7
8
 
 
 
1
 
1
 
 
/* @flow */
"use strict"
 
const alwaysIgnoredGlobs/*: Array<string>*/ = [ "**/node_modules/**", "**/bower_components/**" ]
 
module.exports = alwaysIgnoredGlobs
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
 
1
 
1
1
1
1
1
1
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
 
 
 
 
/* @flow */
"use strict"
const _ = require("lodash")
 
const COMMAND_PREFIX = "stylelint-"
const disableCommand = COMMAND_PREFIX + "disable"
const enableCommand = COMMAND_PREFIX + "enable"
const disableLineCommand = COMMAND_PREFIX + "disable-line"
const disableNextLineCommand = COMMAND_PREFIX + "disable-next-line"
const ALL_RULES = "all"
 
/*:: type disabledRangeObject = {
  [ruleName: string]: Array<{
    start: number,
    end?: number,
  }>
}*/
 
// Run it like a plugin ...
module.exports = function (
  root/*: Object*/,
  result/*: Object*/
)/*: postcss$result*/ {
  result.stylelint = result.stylelint || {}
 
  // Most of the functions below work via side effects mutating
  // this object
  const disabledRanges/*: disabledRangeObject*/ = {
    all: [],
  }
  result.stylelint.disabledRanges = disabledRanges
  root.walkComments(checkComment)
 
  return result
 
  function processDisableLineCommand(comment/*: postcss$comment*/) {
    getCommandRules(disableLineCommand, comment.text).forEach(ruleName => {
      disableLine(comment.source.start.line, ruleName, comment)
    })
  }
 
  function processDisableNextLineCommand(comment/*: postcss$comment*/) {
    getCommandRules(disableNextLineCommand, comment.text).forEach(ruleName => {
      disableLine(comment.source.start.line + 1, ruleName, comment)
    })
  }
 
  function disableLine(
    line/*: number*/,
    ruleName/*: string*/,
    comment/*: postcss$comment*/
  ) {
    if (ruleIsDisabled(ALL_RULES)) {
      throw comment.error("All rules have already been disabled", { plugin: "stylelint" })
    }
    if (ruleIsDisabled(ruleName)) {
      throw comment.error(`"${ruleName}" has already been disabled`, { plugin: "stylelint" })
    }
    if (ruleName === ALL_RULES) {
      Object.keys(disabledRanges).forEach(disabledRuleName => {
        startDisabledRange(line, disabledRuleName)
        endDisabledRange(line, disabledRuleName)
      })
    } else {
      startDisabledRange(line, ruleName)
      endDisabledRange(line, ruleName)
    }
  }
 
  function processDisableCommand(comment/*: postcss$comment*/) {
    getCommandRules(disableCommand, comment.text).forEach(ruleToDisable => {
      if (ruleToDisable === ALL_RULES) {
        if (ruleIsDisabled(ALL_RULES)) {
          throw comment.error("All rules have already been disabled", { plugin: "stylelint" })
        }
        Object.keys(disabledRanges).forEach(ruleName => {
          startDisabledRange(comment.source.start.line, ruleName)
        })
        return
      }
 
      if (ruleIsDisabled(ruleToDisable)) {
        throw comment.error(`"${ruleToDisable}" has already been disabled`, { plugin: "stylelint" })
      }
      startDisabledRange(comment.source.start.line, ruleToDisable)
    })
  }
 
  function processEnableCommand(comment/*: postcss$comment*/) {
    getCommandRules(enableCommand, comment.text).forEach(ruleToEnable => {
      if (ruleToEnable === ALL_RULES) {
        if (_.values(disabledRanges).every(ranges => _.isEmpty(ranges) || !!_.last(ranges.end))) {
          throw comment.error("No rules have been disabled", { plugin: "stylelint" })
        }
        Object.keys(disabledRanges).forEach(ruleName => {
          if (!_.get(_.last(disabledRanges[ruleName]), "end")) {
            endDisabledRange(comment.source.end.line, ruleName)
          }
        })
        return
      }
 
      if (ruleIsDisabled(ALL_RULES) && disabledRanges[ruleToEnable] === undefined) {
        // Get a starting point from the where all rules were disabled
        if (!disabledRanges[ruleToEnable]) {
          disabledRanges[ruleToEnable] = _.cloneDeep(disabledRanges.all)
        } else {
          disabledRanges[ruleToEnable].push(_.clone(_.last(disabledRanges[ALL_RULES])))
        }
        endDisabledRange(comment.source.end.line, ruleToEnable)
        return
      }
 
      if (ruleIsDisabled(ruleToEnable)) {
        endDisabledRange(comment.source.end.line, ruleToEnable)
        return
      }
 
      throw comment.error(`"${ruleToEnable}" has not been disabled`, { plugin: "stylelint" })
    })
  }
 
  function checkComment(comment/*: postcss$comment*/) {
    const text = comment.text
 
    // Ignore comments that are not relevant commands
 
    if (text.indexOf(COMMAND_PREFIX) !== 0) {
      return result
    }
 
    if (text.indexOf(disableLineCommand) === 0) {
      processDisableLineCommand(comment)
    } else if (text.indexOf(disableNextLineCommand) === 0) {
      processDisableNextLineCommand(comment)
    } else if (text.indexOf(disableCommand) === 0) {
      processDisableCommand(comment)
    } else if (text.indexOf(enableCommand) === 0) {
      processEnableCommand(comment)
    }
  }
 
  function getCommandRules(
    command/*: string*/,
    fullText/*: string*/
  )/*: Array<string>*/ {
    const rules = _.compact(fullText.slice(command.length).split(",")).map(r => r.trim())
    if (_.isEmpty(rules)) {
      return [ALL_RULES]
    }
    return rules
  }
 
  function startDisabledRange(line/*: number*/, ruleName/*: string*/) {
    const rangeObj = { start: line }
    ensureRuleRanges(ruleName)
    disabledRanges[ruleName].push(rangeObj)
  }
 
  function endDisabledRange(line/*: number*/, ruleName/*: string*/) {
    const lastRangeForRule = _.last(disabledRanges[ruleName])
    if (!lastRangeForRule) {
      return
    }
    // Add an `end` prop to the last range of that rule
    lastRangeForRule.end = line
  }
 
  function ensureRuleRanges(ruleName/*: string*/) {
    if (!disabledRanges[ruleName]) {
      disabledRanges[ruleName] = _.cloneDeep(disabledRanges.all)
    }
  }
 
  function ruleIsDisabled(ruleName/*: string*/)/*: boolean*/ {
    if (disabledRanges[ruleName] === undefined) return false
    if (_.last(disabledRanges[ruleName]) === undefined) return false
    if (_.get(_.last(disabledRanges[ruleName]), "end") === undefined) return true
    return false
  }
}
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
 
 
1
1
1
1
1
1
1
1
1
 
1
1
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
4
4
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
/* @flow */
"use strict"
const configurationError = require("./utils/configurationError")
const getModulePath = require("./utils/getModulePath")
const _ = require("lodash")
const fs = require("fs")
const globjoin = require("globjoin")
const normalizeRuleSettings = require("./normalizeRuleSettings")
const path = require("path")
const rules = require("./rules")
const dynamicRequire = require("./dynamicRequire")
 
const DEFAULT_IGNORE_FILENAME = ".stylelintignore"
const FILE_NOT_FOUND_ERROR_CODE = "ENOENT"
 
// - Merges config and configOverrides
// - Makes all paths absolute
// - Merges extends
function augmentConfigBasic(
  stylelint/*: stylelint$internalApi*/,
  config/*: stylelint$config*/,
  configDir/*: string*/,
  allowOverrides/*:: ?: boolean*/
)/*: Promise<stylelint$config>*/ {
  return Promise.resolve().then(() => {
    if (!allowOverrides) return config
    return _.merge(config, stylelint._options.configOverrides)
  }).then(augmentedConfig => {
    return extendConfig(stylelint, augmentedConfig, configDir)
  }).then(augmentedConfig => {
    return absolutizePaths(augmentedConfig, configDir)
  })
}
 
// Extended configs need to be run through augmentConfigBasic
// but do not need the full treatment. Things like pluginFunctions
// will be resolved and added by the parent config.
function augmentConfigExtended(
  stylelint/*: stylelint$internalApi*/,
  cosmiconfigResultArg/*: ?{
     config: stylelint$config,
     filepath: string,
   }*/
 )/*: Promise<?{ config: stylelint$config, filepath: string }>*/ {
  const cosmiconfigResult = cosmiconfigResultArg // Lock in for Flow
  if (!cosmiconfigResult) return Promise.resolve(null)
 
  const configDir = path.dirname(cosmiconfigResult.filepath || "")
  const cleanedConfig = _.omit(cosmiconfigResult.config, "ignoreFiles")
  return augmentConfigBasic(stylelint, cleanedConfig, configDir).then(augmentedConfig => {
    return {
      config: augmentedConfig,
      filepath: cosmiconfigResult.filepath,
    }
  })
}
 
function augmentConfigFull(
  stylelint/*: stylelint$internalApi*/,
   cosmiconfigResultArg/*: ?{
   config: stylelint$config,
   filepath: string,
  }*/
)/*: Promise<?{ config: stylelint$config, filepath: string }>*/ {
  const cosmiconfigResult = cosmiconfigResultArg // Lock in for Flow
  Eif (!cosmiconfigResult) return Promise.resolve(null)
 
  const config = cosmiconfigResult.config,
    filepath = cosmiconfigResult.filepath
 
  const configDir = stylelint._options.configBasedir || path.dirname(filepath || "")
 
  return augmentConfigBasic(stylelint, config, configDir, true).then(augmentedConfig => {
    return addIgnorePatterns(stylelint, augmentedConfig)
  }).then(augmentedConfig => {
    return addPluginFunctions(augmentedConfig)
  }).then(augmentedConfig => {
    return addProcessorFunctions(augmentedConfig)
  }).then(augmentedConfig => {
    if (!augmentedConfig.rules) {
      throw configurationError("No rules found within configuration. Have you provided a \"rules\" property?")
    }
 
    return normalizeAllRuleSettings(augmentedConfig)
  }).then(augmentedConfig => {
    return {
      config: augmentedConfig,
      filepath: cosmiconfigResult.filepath,
    }
  })
}
 
// Load a file ignore ignore patterns, if there is one;
// then add them to the config as an ignorePatterns property
function addIgnorePatterns(
  stylelint/*: stylelint$internalApi*/,
  config/*: stylelint$config*/
)/*: Promise<stylelint$config>*/ {
  const ignoreFilePath = stylelint._options.ignorePath || DEFAULT_IGNORE_FILENAME
  const absoluteIgnoreFilePath = path.isAbsolute(ignoreFilePath) ? ignoreFilePath : path.resolve(process.cwd(), ignoreFilePath)
 
  return new Promise((resolve, reject) => {
    fs.readFile(absoluteIgnoreFilePath, "utf8", (err, data) => {
      if (err) {
        // If the file's not found, fine, we'll just
        // consider it an empty array of globs
        if (err.code === FILE_NOT_FOUND_ERROR_CODE) {
          return resolve(config)
        }
        return reject(err)
      }
      // Add an ignorePatterns property to the config, containing the
      // .gitignore-patterned globs loaded from .stylelintignore
      const augmentedConfig/*: stylelint$config*/ = Object.assign({}, config, {
        ignorePatterns: data,
      })
      resolve(augmentedConfig)
    })
  })
}
 
// Make all paths in the config absolute:
// - ignoreFiles
// - plugins
// - processors
// (extends handled elsewhere)
function absolutizePaths(
  config/*: stylelint$config*/,
  configDir/*: string*/
)/*: stylelint$config*/ {
  if (config.ignoreFiles) {
    config.ignoreFiles = [].concat(config.ignoreFiles).map(glob => {
      if (path.isAbsolute(glob.replace(/^!/, ""))) return glob
      return globjoin(configDir, glob)
    })
  }
 
  if (config.plugins) {
    config.plugins = [].concat(config.plugins).map(lookup => {
      return getModulePath(configDir, lookup)
    })
  }
 
  if (config.processors) {
    config.processors = absolutizeProcessors(config.processors, configDir)
  }
 
  return config
}
 
// Processors are absolutized in their own way because
// they can be and return a string or an array
function absolutizeProcessors(
  processors/*: stylelint$configProcessors*/,
  configDir/*: string*/
)/*: stylelint$configProcessors*/ {
  const normalizedProcessors = Array.isArray(processors) ? processors : [processors]
 
  return normalizedProcessors.map(item => {
    if (typeof item === "string") {
      return getModulePath(configDir, item)
    }
 
    return [ getModulePath(configDir, item[0]), item[1] ]
  })
}
 
function extendConfig(
  stylelint/*: stylelint$internalApi*/,
  config/*: stylelint$config*/,
  configDir/*: string*/
)/*: Promise<stylelint$config>*/ {
  if (config.extends === undefined) return Promise.resolve(config)
  const normalizedExtends = Array.isArray(config.extends) ? config.extends : [config.extends]
 
  const originalWithoutExtends = _.omit(config, "extends")
  const loadExtends = normalizedExtends.reduce((resultPromise, extendLookup) => {
    return resultPromise.then(resultConfig => {
      return loadExtendedConfig(stylelint, resultConfig, configDir, extendLookup).then(extendResult => {
        if (!extendResult) return resultConfig
        return mergeConfigs(resultConfig, extendResult.config)
      })
    })
  }, Promise.resolve(originalWithoutExtends))
 
  return loadExtends.then(resultConfig => {
    return mergeConfigs(resultConfig, originalWithoutExtends)
  })
}
 
function loadExtendedConfig(
  stylelint/*: stylelint$internalApi*/,
  config/*: stylelint$config*/,
  configDir/*: string*/,
  extendLookup/*: string*/
)/*: Promise<?{ config: stylelint$config, filepath: string }>*/ {
  const extendPath = getModulePath(configDir, extendLookup)
  return stylelint._extendExplorer.load(null, extendPath)
}
 
// When merging configs (via extends)
// - plugin and processor arrays are joined
// - rules are merged via Object.assign, so there is no attempt made to
//   merge any given rule's settings. If b contains the same rule as a,
//   b's rule settings will override a's rule settings entirely.
// - Everything else is merged via Object.assign
function mergeConfigs(a/*: stylelint$config*/, b/*: stylelint$config*/)/*: stylelint$config*/ {
  const pluginMerger = {}
  if (a.plugins || b.plugins) {
    pluginMerger.plugins = []
    if (a.plugins) {
      pluginMerger.plugins = pluginMerger.plugins.concat(a.plugins)
    }
    if (b.plugins) {
      pluginMerger.plugins = _.uniq(pluginMerger.plugins.concat(b.plugins))
    }
  }
 
  const processorMerger = {}
  if (a.processors || b.processors) {
    processorMerger.processors = []
    if (a.processors) {
      processorMerger.processors = processorMerger.processors.concat(a.processors)
    }
    if (b.processors) {
      processorMerger.processors = _.uniq(processorMerger.processors.concat(b.processors))
    }
  }
 
  const rulesMerger = {}
  if (a.rules || b.rules) {
    rulesMerger.rules = Object.assign({}, a.rules, b.rules)
  }
 
  const result = Object.assign({}, a, b, processorMerger, pluginMerger, rulesMerger)
  return result
}
 
function addPluginFunctions(config/*: stylelint$config*/)/*: stylelint$config*/ {
  if (!config.plugins) return config
 
  const normalizedPlugins = Array.isArray(config.plugins) ? config.plugins : [config.plugins]
 
  const pluginFunctions = normalizedPlugins.reduce((result, pluginLookup) => {
    let pluginImport = dynamicRequire(pluginLookup)
    // Handle either ES6 or CommonJS modules
    pluginImport = pluginImport.default || pluginImport
 
    // A plugin can export either a single rule definition
    // or an array of them
    const normalizedPluginImport = Array.isArray(pluginImport) ? pluginImport : [pluginImport]
 
    normalizedPluginImport.forEach(pluginRuleDefinition => {
      if (!pluginRuleDefinition.ruleName) {
        throw configurationError("stylelint v3+ requires plugins to expose a ruleName. " + `The plugin "${pluginLookup}" is not doing this, so will not work ` + "with stylelint v3+. Please file an issue with the plugin.")
      }
 
      if (!_.includes(pluginRuleDefinition.ruleName, "/")) {
        throw configurationError("stylelint v7+ requires plugin rules to be namspaced, " + "i.e. only `plugin-namespace/plugin-rule-name` plugin rule names are supported. " + `The plugin rule "${pluginRuleDefinition.ruleName}" does not do this, so will not work. ` + "Please file an issue with the plugin.")
      }
 
      result[pluginRuleDefinition.ruleName] = pluginRuleDefinition.rule
    })
 
    return result
  }, {})
 
  config.pluginFunctions = pluginFunctions
  return config
}
 
function normalizeAllRuleSettings(config/*: stylelint$config*/)/*: stylelint$config*/ {
  const normalizedRules = {}
  if (!config.rules) return config
  Object.keys(config.rules).forEach(ruleName => {
    const rawRuleSettings = _.get(config, [ "rules", ruleName ])
    const rule = rules[ruleName] || _.get(config, [ "pluginFunctions", ruleName ])
    if (!rule) {
      throw configurationError(`Undefined rule ${ruleName}`)
    }
    normalizedRules[ruleName] = normalizeRuleSettings(rawRuleSettings, ruleName, _.get(rule, "primaryOptionArray"))
  })
  config.rules = normalizedRules
  return config
}
 
// Given an array of processors strings, we want to add two
// properties to the augmented config:
// - codeProcessors: functions that will run on code as it comes in
// - resultProcessors: functions that will run on results as they go out
//
// To create these properties, we need to:
// - Find the processor module
// - Intialize the processor module by calling its functions with any
//   provided options
// - Push the processor's code and result processors to their respective arrays
const processorCache = new Map()
function addProcessorFunctions(config/*: stylelint$config*/)/*: stylelint$config*/ {
  if (!config.processors) return config
 
  const codeProcessors = []
  const resultProcessors = []
 
  ;[].concat(config.processors).forEach(processorConfig => {
    const processorKey = JSON.stringify(processorConfig)
 
    let initializedProcessor
    if (processorCache.has(processorKey)) {
      initializedProcessor = processorCache.get(processorKey)
    } else {
      processorConfig = [].concat(processorConfig)
      const processorLookup = processorConfig[0]
      const processorOptions = processorConfig[1]
      let processor = dynamicRequire(processorLookup)
      processor = processor.default || processor
      initializedProcessor = processor(processorOptions)
      processorCache.set(processorKey, initializedProcessor)
    }
 
    if (initializedProcessor && initializedProcessor.code) {
      codeProcessors.push(initializedProcessor.code)
    }
    if (initializedProcessor && initializedProcessor.result) {
      resultProcessors.push(initializedProcessor.result)
    }
  })
 
  config.codeProcessors = codeProcessors
  config.resultProcessors = resultProcessors
  return config
}
 
module.exports = { augmentConfigExtended, augmentConfigFull }
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
 
 
 
1
1
1
1
1
1
1
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
1
1
 
 
 
 
1
 
 
 
 
1
 
 
 
1
 
 
 
1
 
 
 
1
 
 
 
 
 
 
 
 
 
1
 
 
 
1
 
 
 
1
 
 
 
1
 
 
 
1
 
 
 
1
 
 
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
 
1
 
 
 
1
1
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1
1
 
 
 
//#!/usr/bin/env node
/* @flow */
"use strict"
const getModulePath = require("./utils/getModulePath")
const getStdin = require("get-stdin")
const meow = require("meow")
const needlessDisablesStringFormatter = require("./formatters/needlessDisablesStringFormatter")
const path = require("path")
const resolveFrom = require("resolve-from")
const standalone = require("./standalone")
const dynamicRequire = require("./dynamicRequire")
 
const minimistOptions = {
  default: {
    config: false,
    f: "string",
    q: false,
  },
  alias: {
    f: "formatter",
    h: "help",
    i: "ignore-path",
    id: "ignore-disables",
    q: "quiet",
    rd: "report-needless-disables",
    s: "syntax",
    v: "version",
    aei: "allow-empty-input",
  },
  boolean: [
    "allow-empty-input",
    "color",
    "help",
    "ignore-disables",
    "no-color",
    "quiet",
    "version",
  ],
}
 
const meowOptions = {
  help: `
    Usage: stylelint [input] [options]
 
    Input: Files(s), glob(s), or nothing to use stdin.
 
      If an input argument is wrapped in quotation marks, it will be passed to
      node-glob for cross-platform glob support. node_modules and
      bower_components are always ignored. You can also pass no input and use
      stdin, instead.
 
    Options:
 
      --config
 
        Path to a specific configuration file (JSON, YAML, or CommonJS), or the
        name of a module in node_modules that points to one. If no --config
        argument is provided, stylelint will search for configuration files in
        the following places, in this order:
          - a stylelint property in package.json
          - a .stylelintrc file (with or without filename extension:
            .json, .yaml, .yml, and .js are available)
          - a stylelint.config.js file exporting a JS object
        The search will begin in the working directory and move up the directory
        tree until a configuration file is found.
 
      --config-basedir
 
        An absolute path to the directory that relative paths defining "extends"
        and "plugins" are *relative to*. Only necessary if these values are
        relative paths.
 
      --ignore-path, -i
 
        Path to a file containing patterns that describe files to ignore. The
        path can be absolute or relative to process.cwd(). By default, stylelint
        looks for .stylelintignore in process.cwd().
 
      --syntax, -s
 
        Specify a non-standard syntax. Options: "scss", "less", "sugarss".
        If you do not specify a syntax, non-standard syntaxes will be
        automatically inferred by the file extensions .scss, .less, and .sss.
 
      --custom-syntax
 
        Module name or path to a JS file exporting a PostCSS-compatible syntax.
 
      --stdin-filename
 
        A filename to assign stdin input.
 
      --ignore-disables, --id
 
        Ignore styleline-disable comments.
        
      --cache                       [default: false]
 
        Store the info about processed files in order to only operate on the 
        changed ones the next time you run stylelint. By default, the cache 
        is stored in "./.stylelintcache". To adjust this, use --cache-location.
 
      --cache-location              [default: '.stylelintcache']
 
        Path to a file or directory to be used for the cache location.
        Default is "./.stylelintcache". If a directory is specified, a cache 
        file will be created inside the specified folder, with a name derived
        from a hash of the current working directory.
 
        If the directory for the cache does not exist, make sure you add a trailing "/" 
        on \*nix systems or "\" on Windows. Otherwise the path will be assumed to be a file.
         
 
      --formatter, -f               [default: "string"]
 
        The output formatter: "json", "string" or "verbose".
 
      --custom-formatter
 
        Path to a JS file exporting a custom formatting function.
 
      --quiet, -q
 
        Only register warnings for rules with an "error"-level severity (ignore
        "warning"-level).
 
      --color
      --no-color
 
        Force enabling/disabling of color.
 
      --allow-empty-input, -aei
 
        If no files match glob pattern, exits without throwing an error.
 
      --report-needless-disables, --rd
 
        Report stylelint-disable comments that are not blocking a lint warning.
        If you provide the argument "error", the process will exit with code 2
        if needless disables are found.
 
      --version, -v
 
        Show the currently installed version of stylelint.
  `,
  pkg: "../package.json",
}
 
const cli = meow(meowOptions, minimistOptions)
 
let formatter = cli.flags.formatter
Iif (cli.flags.customFormatter) {
  const customFormatter = path.isAbsolute(cli.flags.customFormatter) ? cli.flags.customFormatter : path.join(process.cwd(), cli.flags.customFormatter)
  formatter = dynamicRequire(customFormatter)
}
 
const optionsBase/*: Object*/ = {
  formatter,
  configOverrides: {},
}
 
Iif (cli.flags.quiet) {
  optionsBase.configOverrides.quiet = cli.flags.quiet
}
 
Iif (cli.flags.syntax) {
  optionsBase.syntax = cli.flags.syntax
}
 
Iif (cli.flags.customSyntax) {
  optionsBase.customSyntax = getModulePath(process.cwd(), cli.flags.customSyntax)
}
 
Iif (cli.flags.config) {
  // Should check these possibilities:
  //   a. name of a node_module
  //   b. absolute path
  //   c. relative path relative to `process.cwd()`.
  // If none of the above work, we'll try a relative path starting
  // in `process.cwd()`.
  optionsBase.configFile = resolveFrom(process.cwd(), cli.flags.config) || path.join(process.cwd(), cli.flags.config)
}
 
Iif (cli.flags.configBasedir) {
  optionsBase.configBasedir = path.isAbsolute(cli.flags.configBasedir) ? cli.flags.configBasedir : path.resolve(process.cwd(), cli.flags.configBasedir)
}
 
Iif (cli.flags.stdinFilename) {
  optionsBase.codeFilename = cli.flags.stdinFilename
}
 
Iif (cli.flags.ignorePath) {
  optionsBase.ignorePath = cli.flags.ignorePath
}
 
Iif (cli.flags.ignoreDisables) {
  optionsBase.ignoreDisables = cli.flags.ignoreDisables
}
 
Iif (cli.flags.allowEmptyInput) {
  optionsBase.allowEmptyInput = cli.flags.allowEmptyInput
}
 
Iif (cli.flags.cache) {
  optionsBase.cache = true
}
 
Iif (cli.flags.cacheLocation) {
  optionsBase.cacheLocation = cli.flags.cacheLocation
}
 
const reportNeedlessDisables = cli.flags.reportNeedlessDisables
 
Iif (reportNeedlessDisables) {
  optionsBase.reportNeedlessDisables = reportNeedlessDisables
}
 
Promise.resolve().then(() => {
  // Add input/code into options
  Iif (cli.input.length) {
    return Object.assign({}, optionsBase, {
      files: cli.input,
    })
  }
  return getStdin().then(stdin => Object.assign({}, optionsBase, {
    code: stdin,
  }))
}).then(options => {
  Eif (!options.files && !options.code) {
    cli.showHelp()
  }
 
  return standalone(options)
}).then((linted) => {
  if (reportNeedlessDisables) {
    process.stdout.write(needlessDisablesStringFormatter(linted.needlessDisables))
    if (reportNeedlessDisables === "error") {
      process.exitCode = 2
    }
    return
  }
 
  if (!linted.output) {
    return
  }
  process.stdout.write(linted.output)
  if (linted.errored) {
    process.exitCode = 2
  }
}).catch(err => {
  console.log(err.stack) // eslint-disable-line no-console
  const exitCode = typeof err.code === "number" ? err.code : 1
  process.exit(exitCode)
})
 
 

1
2
3
4
5
6
7
8
9
10
 
 
1
 
 
 
 
 
 
 
"use strict"
 
module.exports = function (ruleName, rule) {
  return {
    ruleName,
    rule,
  }
}
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
 
1
1
1
1
1
1
1
1
 
 
 
 
1
1
1
 
 
 
1
 
 
 
 
1
 
 
 
 
1
1
1
1
1
 
1
1
 
1
 
 
 
/* @flow */
"use strict"
const augmentConfig = require("./augmentConfig")
const _ = require("lodash")
const cosmiconfig = require("cosmiconfig")
const createStylelintResult = require("./createStylelintResult")
const getConfigForFile = require("./getConfigForFile")
const getPostcssResult = require("./getPostcssResult")
const isPathIgnored = require("./isPathIgnored")
const lintSource = require("./lintSource")
 
// The stylelint "internal API" is passed among functions
// so that methods on a stylelint instance can invoke
// each other while sharing options and caches
module.exports = function (options/*: stylelint$options*/)/*: stylelint$internalApi*/ {
  options = options || {}
  const stylelint/*: Object*/ = { _options: options }
 
  // Two separate explorers so they can each have their own transform
  // function whose results are cached by cosmiconfig
  stylelint._fullExplorer = cosmiconfig("stylelint", {
    argv: false,
    rcExtensions: true,
    transform: _.partial(augmentConfig.augmentConfigFull, stylelint),
  })
  stylelint._extendExplorer = cosmiconfig(null, {
    argv: false,
    transform: _.partial(augmentConfig.augmentConfigExtended, stylelint),
  })
 
  stylelint._specifiedConfigCache = new Map()
  stylelint._postcssResultCache = new Map()
  stylelint._createStylelintResult = _.partial(createStylelintResult, stylelint)
  stylelint._getPostcssResult = _.partial(getPostcssResult, stylelint)
  stylelint._lintSource = _.partial(lintSource, stylelint)
 
  stylelint.getConfigForFile = _.partial(getConfigForFile, stylelint)
  stylelint.isPathIgnored = _.partial(isPathIgnored, stylelint)
 
  return stylelint
}
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/* @flow */
"use strict"
const _ = require("lodash")
 
module.exports = function (
  stylelint/*: stylelint$internalApi*/,
  postcssResult/*: Object*/,
  filePath/*:: ?: string*/
)/*: Promise<stylelint$result>*/ {
  const source = !postcssResult.root.source ? undefined : postcssResult.root.source.input.file || postcssResult.root.source.input.id
 
  // Strip out deprecation warnings from the messages
  const deprecationMessages = _.remove(postcssResult.messages, { stylelintType: "deprecation" })
  const deprecations = deprecationMessages.map(deprecationMessage => {
    return {
      text: deprecationMessage.text,
      reference: deprecationMessage.stylelintReference,
    }
  })
 
  // Also strip out invalid options
  const invalidOptionMessages = _.remove(postcssResult.messages, { stylelintType: "invalidOption" })
  const invalidOptionWarnings = invalidOptionMessages.map(invalidOptionMessage => {
    return {
      text: invalidOptionMessage.text,
    }
  })
 
  // This defines the stylelint result object that formatters receive
  let stylelintResult = {
    source,
    deprecations,
    invalidOptionWarnings,
    errored: postcssResult.stylelint.stylelintError,
    warnings: postcssResult.messages.map(message => {
      return {
        line: message.line,
        column: message.column,
        rule: message.rule,
        severity: message.severity,
        text: message.text,
      }
    }),
    ignored: postcssResult.stylelint.ignored,
    _postcssResult: postcssResult,
  }
 
  return stylelint.getConfigForFile(filePath).then((result) => {
    const config = result.config
 
    if (config.resultProcessors) {
      config.resultProcessors.forEach(resultProcessor => {
        // Result processors might just mutate the result object,
        // or might return a new one
        const returned = resultProcessor(stylelintResult, source)
        if (returned) {
          stylelintResult = returned
        }
      })
    }
 
    return stylelintResult
  })
}
 
 

1
2
3
4
5
6
7
8
 
 
 
1
 
 
 
 
"use strict"
// This file exists to remove the need for Flow's ignore_non_literal_requires option
 
module.exports = function (name) {
  return require(name)
}
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
 
1
1
1
 
1
 
 
 
1
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
1
 
 
1
1
1
 
 
 
 
 
 
/* @flow */
"use strict"
const augmentConfigFull = require("./augmentConfig").augmentConfigFull
const configurationError = require("./utils/configurationError")
const path = require("path")
 
module.exports = function (
  stylelint/*: stylelint$internalApi*/,
  searchPath/*:: ?: string*/
)/*: Promise<?{ config: stylelint$config, filepath: string }>*/ {
  searchPath = searchPath || process.cwd()
 
  const optionsConfig = stylelint._options.config
 
  Iif (optionsConfig !== undefined) {
    const cached = stylelint._specifiedConfigCache.get(optionsConfig)
    if (cached) return cached
 
    // stylelint._fullExplorer (cosmiconfig) is already configured to
    // run augmentConfigFull; but since we're making up the result here,
    // we need to manually run the transform
    const augmentedResult = augmentConfigFull(stylelint, {
      config: optionsConfig,
      // Add the extra path part so that we can get the directory without being
      // confused
      filepath: path.join(process.cwd(), "argument-config"),
    })
    stylelint._specifiedConfigCache.set(optionsConfig, augmentedResult)
    return augmentedResult
  }
 
  return stylelint._fullExplorer.load(searchPath, stylelint._options.configFile).then(config => {
    // If no config was found, try looking from process.cwd
    Eif (!config) return stylelint._fullExplorer.load(process.cwd())
    return config
  }).then(config => {
    Eif (!config) {
      const ending = searchPath ? ` for ${searchPath}` : ""
      throw configurationError(`No configuration provided${ending}`)
    }
    return config
  })
}
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
 
 
1
1
1
1
1
1
1
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
/* @flow */
"use strict"
 
const fs = require("fs")
const lessSyntax = require("postcss-less")
const path = require("path")
const postcss = require("postcss")
const scssSyntax = require("postcss-scss")
const sugarssSyntax = require("sugarss")
const dynamicRequire = require("./dynamicRequire")
 
const postcssProcessor = postcss()
 
module.exports = function (stylelint/*: stylelint$internalApi*/)/*: Promise<?Object>*/ {
  const options/*: {
    code?: string,
    codeFilename?: string,
    filePath?: string,
    codeProcessors?: Array<Function>,
    syntax?: stylelint$syntaxes,
    customSyntax?: string
  }*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}
 
  const cached/*: ?postcss$result*/ = stylelint._postcssResultCache.get(options.filePath)
  if (cached) return Promise.resolve(cached)
 
  let getCode
  if (options.code !== undefined) {
    getCode = Promise.resolve(options.code)
  } else if (options.filePath) {
    getCode = readFile(options.filePath)
  }
 
  if (!getCode) {
    throw new Error("code or filePath required")
  }
 
  return getCode.then(code => {
    const customSyntax = stylelint._options.customSyntax
    let syntax = stylelint._options.syntax
 
    if (customSyntax) {
      try {
        syntax = dynamicRequire(customSyntax)
      } catch (e) {
        throw new Error(`Cannot resolve custom syntax module ${customSyntax}`)
      }
    } else {
      const fileExtension = path.extname(options.filePath || "")
      if (syntax === "scss" || !syntax && fileExtension === ".scss") {
        syntax = scssSyntax
      } else if (syntax === "less" || !syntax && fileExtension === ".less") {
        syntax = lessSyntax
      } else if (syntax === "sugarss" || !syntax && fileExtension === ".sss") {
        syntax = sugarssSyntax
      } else if (syntax) {
        throw new Error("You must use a valid syntax option, either: scss, less or sugarss")
      }
    }
 
    const postcssOptions/*: postcss$options*/ = {}
 
    postcssOptions.from = options.filePath
 
    /*
     * PostCSS allows for syntaxes that only contain a parser, however,
     * it then expects the syntax to be set as the `parser` option rather than `syntax.
     */
    if (syntax && !syntax.stringify) {
      postcssOptions.parser = syntax
    } else {
      postcssOptions.syntax = syntax
    }
 
    const source = options.code ? options.codeFilename : options.filePath
    let preProcessedCode = code
    if (options.codeProcessors) {
      options.codeProcessors.forEach(codeProcessor => {
        preProcessedCode = codeProcessor(preProcessedCode, source)
      })
    }
 
    return postcssProcessor.process(preProcessedCode, postcssOptions)
  }).then(postcssResult => {
    stylelint._postcssResultCache.set(options.filePath, postcssResult)
    return postcssResult
  })
}
 
function readFile(filePath/*: string*/)/*: Promise<string>*/ {
  return new Promise((resolve, reject) => {
    fs.readFile(filePath, "utf8", (err, content) => {
      if (err) {
        return reject(err)
      }
      resolve(content)
    })
  })
}
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
 
1
1
1
1
1
1
1
1
1
1
1
 
1
 
1
 
 
 
 
 
 
1
1
1
1
1
1
 
1
 
 
"use strict"
 
const report = require("./utils/report")
const ruleMessages = require("./utils/ruleMessages")
const validateOptions = require("./utils/validateOptions")
const checkAgainstRule = require("./utils/checkAgainstRule")
const createPlugin = require("./createPlugin")
const createRuleTester = require("./testUtils/createRuleTester")
const createStylelint = require("./createStylelint")
const postcssPlugin = require("./postcssPlugin")
const rules = require("./rules")
const formatters = require("./formatters")
const standalone = require("./standalone")
 
const api = postcssPlugin
 
api.utils = {
  report,
  ruleMessages,
  validateOptions,
  checkAgainstRule,
}
 
api.lint = standalone
api.rules = rules
api.formatters = formatters
api.createPlugin = createPlugin
api.createRuleTester = createRuleTester
api.createLinter = createStylelint
 
module.exports = api
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
 
1
1
1
 
1
 
 
 
 
 
 
1
 
 
 
1
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/* @flow */
"use strict"
const ignore = require("ignore")
const micromatch = require("micromatch")
const path = require("path")
 
const alwaysIgnoredGlobs = require("./alwaysIgnoredGlobs")
 
// To find out if a path is ignored, we need to load the config,
// which may have an ignoreFiles property,
// and will have incorporated any .stylelintignore file that was found
// into its ignorePatterns property. We then check the path
// against these.
module.exports = function (
  stylelint/*: stylelint$internalApi*/,
  filePathArg/*:: ?: string*/
)/*: Promise<boolean>*/ {
  const filePath = filePathArg // to please Flow
  Eif (!filePath) {
    return Promise.resolve(false)
  }
 
  return stylelint.getConfigForFile(filePath).then((result) => {
    const config = result.config
 
    const absoluteFilePath = path.isAbsolute(filePath) ? filePath : path.resolve(process.cwd(), filePath)
 
    const ignoreFiles = alwaysIgnoredGlobs.concat(config.ignoreFiles || [])
    if (micromatch(absoluteFilePath, ignoreFiles).length) {
      return true
    }
 
    const ignorePatternsFilter = ignore().add(config.ignorePatterns).createFilter()
 
    const filepathRelativeToCwd = path.relative(process.cwd(), filePath)
 
    if (ignorePatternsFilter && !ignorePatternsFilter(filepathRelativeToCwd)) {
      return true
    }
 
    return false
  })
}
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
 
1
1
1
1
1
 
 
 
1
 
 
 
 
 
 
 
 
1
 
1
 
 
 
1
 
1
1
 
 
 
 
 
 
 
1
 
 
 
 
1
1
 
 
 
 
 
 
 
1
 
1
1
1
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
/* @flow */
"use strict"
const _ = require("lodash")
const assignDisabledRanges = require("./assignDisabledRanges")
const configurationError = require("./utils/configurationError")
const path = require("path")
const ruleDefinitions = require("./rules")
 
// Run stylelint on a PostCSS Result, either one that is provided
// or one that we create
module.exports = function (
  stylelint/*: stylelint$internalApi*/,
  options/*: {
    code?: string,
    codeFilename?: string, // Must be an absolute file path
    filePath?: string, // Must be an absolute file path
    existingPostcssResult?: Object,
  }*/
)/*: Promise<Object>*/ {
  options = options || {}
 
  Iif (!options.filePath && options.code === undefined && !options.existingPostcssResult) {
    return Promise.reject(new Error("You must provide filePath, code, or existingPostcssResult"))
  }
 
  const isCodeNotFile = options.code !== undefined
 
  const inputFilePath = isCodeNotFile ? options.codeFilename : options.filePath
  Iif (inputFilePath !== undefined && !path.isAbsolute(inputFilePath)) {
    if (isCodeNotFile) {
      return Promise.reject(new Error("codeFilename must be an absolute path"))
    } else {
      return Promise.reject(new Error("filePath must be an absolute path"))
    }
  }
 
  const getIsIgnored = stylelint.isPathIgnored(inputFilePath).catch(err => {
    if (isCodeNotFile && err.code === "ENOENT") return false
    throw err
  })
 
  return getIsIgnored.then(isIgnored => {
    Iif (isIgnored) {
      const postcssResult = options.existingPostcssResult || createEmptyPostcssResult(inputFilePath)
      postcssResult.stylelint = postcssResult.stylelint || {}
      postcssResult.stylelint.ignored = true
      postcssResult.standaloneIgnored = true // TODO: remove need for this
      return postcssResult
    }
 
    const configSearchPath = stylelint._options.configFile || inputFilePath
 
    const getConfig = stylelint.getConfigForFile(configSearchPath).catch(err => {
      Iif (isCodeNotFile && err.code === "ENOENT") return stylelint.getConfigForFile(process.cwd())
      throw err
    })
 
    return getConfig.then((result) => {
      const config = result.config
      const existingPostcssResult = options.existingPostcssResult
 
      if (existingPostcssResult) {
        return lintPostcssResult(stylelint, existingPostcssResult, config).then(() => existingPostcssResult)
      }
 
      return stylelint._getPostcssResult({
        code: options.code,
        codeFilename: options.codeFilename,
        filePath: inputFilePath,
        codeProcessors: config.codeProcessors,
      }).then(postcssResult => {
        return lintPostcssResult(stylelint, postcssResult, config).then(() => postcssResult)
      })
    })
  })
}
 
function lintPostcssResult(
  stylelint/*: stylelint$internalApi*/,
  postcssResult/*: Object*/,
  config/*: stylelint$config*/
)/*: Promise<>*/ {
  postcssResult.stylelint = postcssResult.stylelint || {}
  postcssResult.stylelint.ruleSeverities = {}
  postcssResult.stylelint.customMessages = {}
  postcssResult.stylelint.quiet = config.quiet
 
  const postcssRoot = postcssResult.root
  assignDisabledRanges(postcssRoot, postcssResult)
  if (stylelint._options.reportNeedlessDisables || stylelint._options.ignoreDisables) {
    postcssResult.stylelint.ignoreDisables = true
  }
 
  // Promises for the rules. Although the rule code runs synchronously now,
  // the use of Promises makes it compatible with the possibility of async
  // rules down the line.
  const performRules = []
 
  const rules = config.rules ? Object.keys(config.rules) : []
 
  rules.forEach(ruleName => {
    const ruleFunction = ruleDefinitions[ruleName] || _.get(config, [ "pluginFunctions", ruleName ])
 
    if (ruleFunction === undefined) {
      throw configurationError(`Undefined rule ${ruleName}`)
    }
 
    const ruleSettings = _.get(config, [ "rules", ruleName ])
    if (ruleSettings === null || ruleSettings[0] === null) {
      return
    }
 
    const primaryOption = ruleSettings[0]
    const secondaryOptions = ruleSettings[1]
 
    // Log the rule's severity in the PostCSS result
    const defaultSeverity = config.defaultSeverity || "error"
    postcssResult.stylelint.ruleSeverities[ruleName] = _.get(secondaryOptions, "severity", defaultSeverity)
    postcssResult.stylelint.customMessages[ruleName] = _.get(secondaryOptions, "message")
 
    const performRule = Promise.resolve().then(() => {
      return ruleFunction(primaryOption, secondaryOptions)(postcssRoot, postcssResult)
    })
    performRules.push(performRule)
  })
 
  return Promise.all(performRules)
}
 
function createEmptyPostcssResult(filePath/*:: ?: string*/)/*: Object*/ {
  return {
    root: {
      source: {
        input: { file: filePath },
      },
    },
    messages: [],
    stylelint: { stylelintError: null },
  }
}
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
 
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/* @flow */
"use strict"
 
const _ = require("lodash")
 
module.exports = function (results/*: Array<stylelint$result>*/)/*: stylelint$needlessDisablesReport*/ {
  const report = []
 
  results.forEach(result => {
    // File with `CssSyntaxError` have not `_postcssResult`
    if (!result._postcssResult) {
      return
    }
 
    const unused = { source: result.source, ranges: [] }
    const rangeData = _.cloneDeep(result._postcssResult.stylelint.disabledRanges)
 
    if (!rangeData) {
      return
    }
 
    result.warnings.forEach(warning => {
      const rule/*: string*/ = warning.rule
 
      const ruleRanges = rangeData[rule]
      if (ruleRanges) {
        // Back to front so we get the *last* range that applies to the warning
        for (const range of ruleRanges.reverse()) {
          if (isWarningInRange(warning, range)) {
            range.used = true
            return
          }
        }
      }
 
      for (const range of rangeData.all.reverse()) {
        if (isWarningInRange(warning, range)) {
          range.used = true
          return
        }
      }
    })
 
    Object.keys(rangeData).forEach(rule => {
      rangeData[rule].forEach(range => {
        // Is an equivalent range already marked as unused?
        const alreadyMarkedUnused = unused.ranges.find(unusedRange => {
          return unusedRange.start === range.start && unusedRange.end === range.end
        })
 
        // If this range is unused and no equivalent is marked,
        // mark this range as unused
        if (!range.used && !alreadyMarkedUnused) {
          unused.ranges.push(range)
        }
 
        // If this range is used but an equivalent has been marked as unused,
        // remove that equivalent. This can happen because of the duplication
        // of ranges in rule-specific range sets and the "all" range set
        if (range.used && alreadyMarkedUnused) {
          _.remove(unused.ranges, alreadyMarkedUnused)
        }
      })
    })
 
    unused.ranges = _.sortBy(unused.ranges, [ "start", "end" ])
 
    report.push(unused)
  })
 
  return report
}
 
function isWarningInRange(
  warning/*: {
    rule: string,
    line: number,
  }*/,
  range/*: {
    rules?: Array<string>,
    start: number,
    end?: number,
  }*/
)/*: boolean*/ {
  const rule = warning.rule,
    line = warning.line
 
  // Need to check if range.end exist, because line number type cannot be compared to undefined
  return range.start <= line && (range.end !== undefined && range.end >= line || range.end === undefined) && (!range.rules || range.rules.indexOf(rule) !== -1)
}
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
 
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/* @flow */
"use strict"
const _ = require("lodash")
const rules = require("./rules")
 
// Rule settings can take a number of forms, e.g.
// a. "rule-name": null
// b. "rule-name": [null, ...]
// c. "rule-name": primaryOption
// d. "rule-name": [primaryOption]
// e. "rule-name": [primaryOption, secondaryOption]
// Where primaryOption can be anything: primitive, Object, or Array.
//
// This function normalizes all the possibilities into the
// standard form: [primaryOption, secondaryOption]
// Except in the cases with null, a & b, in which case
// null is returned
module.exports = function (
  rawSettings/*: stylelint$configRuleSettings*/,
  ruleName/*: string*/,
  // If primaryOptionArray is not provided, we try to get it from the
  // rules themselves, which will not work for plugins
  primaryOptionArray/*:: ?: boolean*/
)/*: [any, Object] | Array<any | [any, Object]> | null*/ {
  if (rawSettings === null) {
    return null
  }
 
  if (!Array.isArray(rawSettings)) {
    return [rawSettings]
  }
  // Everything below is an array ...
 
  if (rawSettings[0] === null) {
    return null
  }
 
  // This cursed rule needs a special case
  if (ruleName === "declaration-block-properties-order") {
    if (rawSettings[0] === "alphabetical") {
      return rawSettings
    }
    if (typeof rawSettings[0] === "string") {
      return [rawSettings]
    }
  }
 
  if (primaryOptionArray === undefined) {
    const rule = rules[ruleName]
    primaryOptionArray = _.get(rule, "primaryOptionArray")
  }
 
  if (!primaryOptionArray) {
    return rawSettings
  }
  // Everything below is a rule that CAN have an array for a primary option ...
  // (they might also have something else, e.g. rule-properties-order can
  // have the string "alphabetical")
 
  if (rawSettings.length === 1 && Array.isArray(rawSettings[0])) {
    return rawSettings
  }
 
  if (rawSettings.length === 2 && !_.isPlainObject(rawSettings[0]) && _.isPlainObject(rawSettings[1])) {
    return rawSettings
  }
 
  return [rawSettings]
}
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
 
1
1
1
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/* @flow */
"use strict"
const _ = require("lodash")
const createStylelint = require("./createStylelint")
const postcss = require("postcss")
const path = require("path")
 
module.exports = postcss.plugin("stylelint", function (options) {
  options = options || {}
 
  const tailoredOptions/*: Object*/ = options.rules
    ? { config: options }
    : options
  const stylelint = createStylelint(tailoredOptions)
 
  return (root, result) => {
    let filePath = options.from || _.get(root, "source.input.file")
    if (filePath !== undefined && !path.isAbsolute(filePath)) {
      filePath = path.join(process.cwd(), filePath)
    }
 
    return stylelint._lintSource({
      filePath,
      existingPostcssResult: result,
    })
  }
})
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
 
 
1
1
1
1
1
1
1
1
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
 
1
 
1
1
 
 
 
1
1
1
1
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
1
1
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1
 
 
1
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/* @flow */
"use strict"
const path = require("path")
const formatters/*: Object*/ = require("./formatters")
const createStylelint = require("./createStylelint")
const globby/*: Function*/ = require("globby")
const needlessDisables/*: Function*/ = require("./needlessDisables")
const alwaysIgnoredGlobs = require("./alwaysIgnoredGlobs")
const FileCache = require("./utils/FileCache")
const debug = require("debug")("stylelint:standalone")
const pkg = require("../package.json")
const hash = require("./utils/hash")
 
/*::type CssSyntaxErrorT = {
  column: number;
  file?: string;
  input: {
    column: number;
    file?: string;
    line: number;
    source: string;
  };
  line: number;
  message: string;
  name: string;
  reason: string;
  source: string;
}*/
 
module.exports = function (options/*: stylelint$standaloneOptions */)/*: Promise<stylelint$standaloneReturnValue>*/ {
  const files = options.files
  const code = options.code
  const codeFilename = options.codeFilename
  const config = options.config
  const configFile = options.configFile
  const configBasedir = options.configBasedir
  const configOverrides = options.configOverrides
  const ignoreDisables = options.ignoreDisables
  const ignorePath = options.ignorePath
  const reportNeedlessDisables = options.reportNeedlessDisables
  const formatter = options.formatter
  const syntax = options.syntax
  const customSyntax = options.customSyntax
  const allowEmptyInput = options.allowEmptyInput
  const cacheLocation = options.cacheLocation
  const useCache = options.cache || false
  let fileCache
 
  const startTime = Date.now()
 
  const isValidCode = typeof code === "string"
  Iif (!files && !isValidCode || files && (code || isValidCode)) {
    throw new Error("You must pass stylelint a `files` glob or a `code` string, though not both")
  }
 
  let formatterFunction
  Eif (typeof formatter === "string") {
    formatterFunction = formatters[formatter]
    Iif (formatterFunction === undefined) {
      return Promise.reject(new Error("You must use a valid formatter option: 'json', 'string', 'verbose', or a function"))
    }
  } else if (typeof formatter === "function") {
    formatterFunction = formatter
  } else {
    formatterFunction = formatters.json
  }
 
  const stylelint = createStylelint({
    config,
    configFile,
    configBasedir,
    configOverrides,
    ignoreDisables,
    ignorePath,
    reportNeedlessDisables,
    syntax,
    customSyntax,
  })
 
  Eif (!files) {
    const absoluteCodeFilename = (codeFilename !== undefined && !path.isAbsolute(codeFilename))
      ? path.join(process.cwd(), codeFilename)
      : codeFilename
    return stylelint._lintSource({
      code,
      codeFilename: absoluteCodeFilename,
    }).then(postcssResult => {
      return stylelint._createStylelintResult(postcssResult)
    }).catch(handleError).then(stylelintResult => {
      return prepareReturnValue([stylelintResult])
    })
  }
 
  let fileList = files
  if (typeof fileList === "string") {
    fileList = [fileList]
  }
  fileList = fileList.concat(
    alwaysIgnoredGlobs.map(file => "!" + file)
  )
 
  if (useCache) {
    const stylelintVersion = pkg.version
    const hashOfConfig = hash(`${stylelintVersion}_${JSON.stringify(config)}`)
    fileCache = new FileCache(cacheLocation, hashOfConfig)
  } else {
    // No need to calculate hash here, we just want to delete cache file.
    fileCache = new FileCache(cacheLocation)
    // Remove cache file if cache option is disabled
    fileCache.destroy()
  }
 
  return globby(fileList).then(filePaths => {
    if (!filePaths.length) {
      if (allowEmptyInput === undefined || !allowEmptyInput) {
        const message = (files => {
          if (typeof files === "string") {
            return `${files} does`
          }
          // seperate files into last (last file) and initial) all the others
          const initial = files.slice(0)
          const last = initial.pop()
          // join into a comma seperated string of file names
          const ending = (files.length > 1 ? `and ${last} do` : `${last} does`)
          return `${initial.join(", ")} ${ending}`.trim()
        })(files) + " not match any files"
 
        const err/*: Object*/ = new Error(message)
        err.code = 80
        throw err
      } else {
        return Promise.all([])
      }
    }
 
    let absoluteFilePaths = filePaths.map(filePath => {
      const absoluteFilepath = (!path.isAbsolute(filePath))
        ? path.join(process.cwd(), filePath)
        : path.normalize(filePath)
      return absoluteFilepath
    })
 
    if (useCache) {
      absoluteFilePaths = absoluteFilePaths.filter(fileCache.hasFileChanged.bind(fileCache))
    }
 
    const getStylelintResults = absoluteFilePaths.map(absoluteFilepath => {
      debug(`Processing ${absoluteFilepath}`)
      return stylelint._lintSource({
        filePath: absoluteFilepath,
      }).then(postcssResult => {
        if (postcssResult.stylelint.stylelintError && useCache) {
          debug(`${absoluteFilepath} contains linting errors and will not be cached.`)
          fileCache.removeEntry(absoluteFilepath)
        }
        return stylelint._createStylelintResult(postcssResult, absoluteFilepath)
      }).catch(handleError)
    })
 
    return Promise.all(getStylelintResults)
  }).then(prepareReturnValue)
 
  function prepareReturnValue(stylelintResults/*: Array<stylelint$result>*/)/*: stylelint$standaloneReturnValue*/ {
    const errored = stylelintResults.some(result => result.errored)
    const returnValue/*: stylelint$standaloneReturnValue*/ = {
      errored,
      output: formatterFunction(stylelintResults),
      results: stylelintResults,
    }
    if (reportNeedlessDisables) {
      returnValue.needlessDisables = needlessDisables(stylelintResults)
    }
    if (useCache) {
      fileCache.reconcile()
    }
    debug(`Linting complete in ${Date.now() - startTime}ms`)
    return returnValue
  }
}
 
function handleError(error/*: Object*/) {
  Iif (error.name === "CssSyntaxError") {
    return convertCssSyntaxErrorToResult(error)
  } else {
    throw error
  }
}
 
// By converting syntax errors to stylelint results,
// we can control their appearance in the formatted output
// and other tools like editor plugins can decide how to
// present them, as well
function convertCssSyntaxErrorToResult(error/*: CssSyntaxErrorT*/)/*: stylelint$result*/ {
  if (error.name !== "CssSyntaxError") {
    throw error
  }
 
  return {
    source: error.file || "<input css 1>",
    deprecations: [],
    invalidOptionWarnings: [],
    errored: true,
    warnings: [{
      line: error.line,
      column: error.column,
      rule: error.name,
      severity: "error",
      text: error.reason + " (" + error.name + ")",
    }],
  }
}
 
 

1
2
3
4
5
6
7
8
9
 
 
1
 
 
 
 
 
 
"use strict"
 
module.exports = {
  json: require("./jsonFormatter"),
  string: require("./stringFormatter"),
  verbose: require("./verboseFormatter"),
}
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
1
 
 
1
 
 
 
 
 
 
 
"use strict"
 
const _ = require("lodash")
 
// Omit any properties starting with `_`, which are fake-private
module.exports = function (results) {
  const cleanedResults = results.map(result => {
    return _.omitBy(result, (value, key) => key[0] === "_")
  })
  return JSON.stringify(cleanedResults)
}
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
 
1
1
 
1
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
"use strict"
 
const chalk = require("chalk")
const path = require("path")
 
function logFrom(fromValue) {
  if (fromValue.charAt(0) === "<") return fromValue
  return path.relative(process.cwd(), fromValue).split(path.sep).join("/")
}
 
module.exports = function (report) {
  let output = ""
 
  report.forEach(sourceReport => {
    if (!sourceReport.ranges || sourceReport.ranges.length === 0) {
      return
    }
    output += "\n"
    output += chalk.underline(logFrom(sourceReport.source)) + "\n"
    sourceReport.ranges.forEach(range => {
      output += `start: ${range.start}`
      if (range.end !== undefined) {
        output += `, end: ${range.end}`
      }
      output += "\n"
    })
  })
 
  return output
}
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
 
1
1
1
1
1
1
1
 
1
 
1
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
"use strict"
 
const table = require("table")
const _ = require("lodash")
const chalk = require("chalk")
const path = require("path")
const stringWidth = require("string-width")
const symbols = require("log-symbols")
const utils = require("postcss-reporter/lib/util")
 
const MARGIN_WIDTHS = 9
 
const levelColors = {
  info: "blue",
  warning: "yellow",
  error: "red",
}
 
function deprecationsFormatter(results) {
  const allDeprecationWarnings = _.flatMap(results, "deprecations")
  const uniqueDeprecationWarnings = _.uniqBy(allDeprecationWarnings, "text")
 
  if (!uniqueDeprecationWarnings || !uniqueDeprecationWarnings.length) {
    return ""
  }
 
  return uniqueDeprecationWarnings.reduce((output, warning) => {
    output += chalk.yellow("Deprecation Warning: ")
    output += warning.text
    if (warning.reference) {
      output += chalk.dim(" See: ")
      output += chalk.dim.underline(warning.reference)
    }
    return output + "\n"
  }, "\n")
}
 
function invalidOptionsFormatter(results) {
  const allInvalidOptionWarnings = _.flatMap(results, r => r.invalidOptionWarnings.map(w => w.text))
  const uniqueInvalidOptionWarnings = _.uniq(allInvalidOptionWarnings)
 
  return uniqueInvalidOptionWarnings.reduce((output, warning) => {
    output += chalk.red("Invalid Option: ")
    output += warning
    return output + "\n"
  }, "\n")
}
 
function logFrom(fromValue) {
  if (fromValue.charAt(0) === "<") return fromValue
  return path.relative(process.cwd(), fromValue).split(path.sep).join("/")
}
 
function getMessageWidth(columnWidths) {
  if (!process.stdout.isTTY) {
    return columnWidths[3]
  }
 
  const availableWidth = process.stdout.columns < 80 ? 80 : process.stdout.columns
  const fullWidth = _.sum(_.values(columnWidths))
 
  // If there is no reason to wrap the text, we won't align the last column to the right
  if (availableWidth > fullWidth + MARGIN_WIDTHS) {
    return columnWidths[3]
  }
 
  return availableWidth - (fullWidth - columnWidths[3] + MARGIN_WIDTHS)
}
 
function formatter(messages, source) {
  if (!messages.length) return ""
 
  const orderedMessages = _.sortBy(messages, m => m.line ? 2 : 1, // positionless first
  m => m.line, m => m.column)
 
  // Create a list of column widths, needed to calculate
  // the size of the message column and if needed wrap it.
  const columnWidths = { 0: 1, 1: 1, 2: 1, 3: 1, 4: 1 }
 
  const calculateWidths = function (columns) {
    _.forOwn(columns, (value, key) => {
      const normalisedValue = value ? value.toString() : value
      columnWidths[key] = Math.max(columnWidths[key], stringWidth(normalisedValue))
    })
 
    return columns
  }
 
  let output = "\n"
 
  if (source) {
    output += chalk.underline(logFrom(source)) + "\n"
  }
 
  const cleanedMessages = orderedMessages.map(message => {
    const location = utils.getLocation(message)
    const severity = message.severity
    const row = [ location.line || "", location.column || "", symbols[severity] ? chalk[levelColors[severity]](symbols[severity]) : severity, message.text
    // Remove all control characters (newline, tab and etc)
    .replace(/[\x01-\x1A]+/g, " ") // eslint-disable-line
    .replace(/\.$/, "").replace(new RegExp(_.escapeRegExp("(" + message.rule + ")") + "$"), ""), chalk.dim(message.rule || "") ]
 
    calculateWidths(row)
 
    return row
  })
 
  output += table.table(cleanedMessages, {
    border: table.getBorderCharacters("void"),
    columns: {
      0: { alignment: "right", width: columnWidths[0], paddingRight: 0 },
      1: { alignment: "left", width: columnWidths[1] },
      2: { alignment: "center", width: columnWidths[2] },
      3: { alignment: "left", width: getMessageWidth(columnWidths), wrapWord: true },
      4: { alignment: "left", width: columnWidths[4], paddingRight: 0 },
    },
    drawHorizontalLine: () => false,
  }).split("\n").map(el => el.replace(/(\d+)\s+(\d+)/, (m, p1, p2) => chalk.dim(p1 + ":" + p2))).join("\n")
 
  return output
}
 
module.exports = function (results) {
  let output = invalidOptionsFormatter(results)
  output += deprecationsFormatter(results)
 
  output = results.reduce((output, result) => {
    output += formatter(result.warnings, result.source)
    return output
  }, output)
 
  // Ensure consistent padding
  output = output.trim()
 
  if (output !== "") {
    output = "\n" + output + "\n\n"
  }
 
  return output
}
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
 
1
1
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
"use strict"
 
const _ = require("lodash")
const chalk = require("chalk")
const stringFormatter = require("./stringFormatter")
 
module.exports = function (results) {
  let output = stringFormatter(results)
 
  if (output === "") {
    output = "\n"
  }
 
  const sourceWord = results.length > 1 ? "sources" : "source"
  const ignoredCount = results.filter(result => result.ignored).length
  const checkedDisplay = ignoredCount ? `${results.length - ignoredCount} of ${results.length}` : results.length
  output += chalk.underline(`${checkedDisplay} ${sourceWord} checked\n`)
  results.forEach(result => {
    let formatting = "green"
    if (result.errored) {
      formatting = "red"
    } else if (result.warnings.length) {
      formatting = "yellow"
    } else if (result.ignored) {
      formatting = "dim"
    }
    let sourceText = `${result.source}`
    if (result.ignored) {
      sourceText += " (ignored)"
    }
    output += _.get(chalk, formatting)(` ${sourceText}\n`)
  })
 
  const warnings = _.flatten(results.map(r => r.warnings))
  const warningsBySeverity = _.groupBy(warnings, "severity")
  const problemWord = warnings.length === 1 ? "problem" : "problems"
 
  output += chalk.underline(`\n${warnings.length} ${problemWord} found\n`)
 
  _.forOwn(warningsBySeverity, (warningList, severityLevel) => {
    const warningsByRule = _.groupBy(warningList, "rule")
    output += ` severity level "${severityLevel}": ${warningList.length}\n`
    _.forOwn(warningsByRule, (list, rule) => {
      output += chalk.dim(`  ${rule}: ${list.length}\n`)
    })
  })
 
  return output + "\n"
}
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
 
 
1
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
1
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
 
 
 
1
 
 
 
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
1
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
1
 
1
 
 
 
 
 
 
1
 
 
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
1
 
 
 
 
 
 
 
 
1
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
1
 
 
 
 
 
 
1
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
1
 
1
 
 
 
 
1
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
1
 
1
 
 
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
1
 
1
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
27
 
27
70
 
 
 
1
 
 
"use strict"
 
const _ = require("lodash")
 
const keywordSets = {}
 
keywordSets.nonLengthUnits = new Set([
  // Relative length units
  "%",
  // Time length units
  "s",
  "ms",
  // Angle
  "deg",
  "grad",
  "turn",
  "rad",
  // Frequency
  "Hz",
  "kHz",
  // Resolution
  "dpi",
  "dpcm",
  "dppx",
])
 
keywordSets.lengthUnits = new Set([
  // Relative length units
  "em",
  "ex",
  "ch",
  "rem",
  // Viewport-percentage lengths
  "vh",
  "vw",
  "vmin",
  "vmax",
  "vm",
  // Absolute length units
  "px",
  "mm",
  "cm",
  "in",
  "pt",
  "pc",
  "q",
  // Flexible length units
  "fr",
])
 
keywordSets.units = uniteSets(keywordSets.nonLengthUnits, keywordSets.lengthUnits)
 
keywordSets.colorFunctionNames = new Set([
  "rgb",
  "rgba",
  "hsl",
  "hsla",
  "hwb",
  "gray",
])
 
keywordSets.camelCaseFunctionNames = new Set([
  "translateX",
  "translateY",
  "translateZ",
  "scaleX",
  "scaleY",
  "scaleZ",
  "rotateX",
  "rotateY",
  "rotateZ",
  "skewX",
  "skewY",
])
 
keywordSets.basicKeywords = new Set([
  "initial",
  "inherit",
  "unset",
])
 
keywordSets.fontFamilyKeywords = uniteSets(keywordSets.basicKeywords, [
  "serif",
  "sans-serif",
  "cursive",
  "fantasy",
  "monospace",
])
 
keywordSets.fontWeightRelativeKeywords = new Set([
  "bolder",
  "lighter",
])
 
keywordSets.fontWeightAbsoluteKeywords = new Set(["bold"])
 
keywordSets.fontWeightNumericKeywords = new Set([
  "100",
  "200",
  "300",
  "400",
  "500",
  "600",
  "700",
  "800",
  "900",
])
 
keywordSets.fontWeightKeywords = uniteSets(
  keywordSets.basicKeywords,
  keywordSets.fontWeightRelativeKeywords,
  keywordSets.fontWeightAbsoluteKeywords,
  keywordSets.fontWeightNumericKeywords
)
 
keywordSets.animationNameKeywords = uniteSets(keywordSets.basicKeywords,
  ["none"]
)
 
keywordSets.animationTimingFunctionKeywords = uniteSets(keywordSets.basicKeywords, [
  "linear",
  "ease",
  "ease-in",
  "ease-in-out",
  "ease-out",
  "step-start",
  "step-end",
  "steps",
  "cubic-bezier",
])
 
keywordSets.animationIterationCountKeywords = new Set(["infinite"])
 
keywordSets.animationDirectionKeywords = uniteSets(keywordSets.basicKeywords, [
  "normal",
  "reverse",
  "alternate",
  "alternate-reverse",
])
 
keywordSets.animationFillModeKeywords = new Set([
  "none",
  "forwards",
  "backwards",
  "both",
])
 
keywordSets.animationPlayStateKeywords = uniteSets(keywordSets.basicKeywords, [
  "running",
  "paused",
])
 
// cf. https://developer.mozilla.org/en-US/docs/Web/CSS/animation
keywordSets.animationShorthandKeywords = uniteSets(
  keywordSets.basicKeywords,
  keywordSets.animationNameKeywords,
  keywordSets.animationTimingFunctionKeywords,
  keywordSets.animationIterationCountKeywords,
  keywordSets.animationDirectionKeywords,
  keywordSets.animationFillModeKeywords,
  keywordSets.animationPlayStateKeywords
)
 
// These are the ones that can have single-colon notation
keywordSets.levelOneAndTwoPseudoElements = new Set([
  "before",
  "after",
  "first-line",
  "first-letter",
])
 
// These are the ones that require double-colon notation
keywordSets.levelThreePseudoElements = new Set([
  "before",
  "after",
  "first-line",
  "first-letter",
  "selection",
  "spelling-error",
  "grammar-error",
  "backdrop",
  "marker",
  "placeholder",
  "shadow",
  "slotted",
  "content",
])
 
keywordSets.pseudoElements = uniteSets(
  keywordSets.levelOneAndTwoPseudoElements,
  keywordSets.levelThreePseudoElements
)
 
keywordSets.aNPlusBNotationPseudoClasses = new Set([
  "nth-child",
  "nth-column",
  "nth-last-child",
  "nth-last-column",
  "nth-last-of-type",
  "nth-of-type",
])
 
keywordSets.linguisticPseudoClasses = new Set([
  "dir",
  "lang",
])
 
keywordSets.otherPseudoClasses = new Set([
  "active",
  "any-link",
  "blank",
  "checked",
  "contains",
  "current",
  "default",
  "disabled",
  "drop",
  "empty",
  "enabled",
  "first-child",
  "first-of-type",
  "focus",
  "focus-within",
  "fullscreen",
  "future",
  "has",
  "host",
  "host-context",
  "hover",
  "indeterminate",
  "in-range",
  "invalid",
  "last-child",
  "last-of-type",
  "link",
  "matches",
  "not",
  "only-child",
  "only-of-type",
  "optional",
  "out-of-range",
  "past",
  "placeholder-shown",
  "read-only",
  "read-write",
  "required",
  "root",
  "scope",
  "target",
  "user-error",
  "user-invalid",
  "val",
  "valid",
  "visited",
])
 
keywordSets.webkitProprietaryPseudoElements = new Set([
  "scrollbar",
  "scrollbar-button",
  "scrollbar-track",
  "scrollbar-track-piece",
  "scrollbar-thumb",
  "scrollbar-corner",
  "resize",
])
 
keywordSets.webkitProprietaryPseudoClasses = new Set([
  "horizontal",
  "vertical",
  "decrement",
  "increment",
  "start",
  "end",
  "double-button",
  "single-button",
  "no-button",
  "corner-present",
  "window-inactive",
])
 
keywordSets.pseudoClasses = uniteSets(
  keywordSets.aNPlusBNotationPseudoClasses,
  keywordSets.linguisticPseudoClasses,
  keywordSets.otherPseudoClasses
)
 
keywordSets.shorthandTimeProperties = new Set([
  "transition",
  "animation",
])
 
keywordSets.longhandTimeProperties = new Set([
  "transition-duration",
  "transition-delay",
  "animation-duration",
  "animation-delay",
])
 
keywordSets.timeProperties = uniteSets(
  keywordSets.shorthandTimeProperties,
  keywordSets.longhandTimeProperties
)
 
keywordSets.camelCaseKeywords = new Set([
  "optimizeSpeed",
  "optimizeQuality",
  "optimizeLegibility",
  "geometricPrecision",
  "currentColor",
  "crispEdges",
  "visiblePainted",
  "visibleFill",
  "visibleStroke",
  "sRGB",
  "linearRGB",
])
 
// https://developer.mozilla.org/docs/Web/CSS/counter-increment
keywordSets.counterIncrementKeywords = uniteSets(keywordSets.basicKeywords, ["none"])
 
keywordSets.counterResetKeywords = uniteSets(keywordSets.basicKeywords, ["none"])
 
keywordSets.gridRowKeywords = uniteSets(keywordSets.basicKeywords, [
  "auto",
  "span",
])
 
keywordSets.gridColumnKeywords = uniteSets(keywordSets.basicKeywords, [
  "auto",
  "span",
])
 
keywordSets.gridAreaKeywords = uniteSets(keywordSets.basicKeywords, [
  "auto",
  "span",
])
 
// https://developer.mozilla.org/ru/docs/Web/CSS/list-style-type
keywordSets.listStyleTypeKeywords = uniteSets(keywordSets.basicKeywords, [
  "none",
  "disc",
  "circle",
  "square",
  "decimal",
  "cjk-decimal",
  "decimal-leading-zero",
  "lower-roman",
  "upper-roman",
  "lower-greek",
  "lower-alpha",
  "lower-latin",
  "upper-alpha",
  "upper-latin",
  "arabic-indic",
  "armenian",
  "bengali",
  "cambodian",
  "cjk-earthly-branch",
  "cjk-ideographic",
  "devanagari",
  "ethiopic-numeric",
  "georgian",
  "gujarati",
  "gurmukhi",
  "hebrew",
  "hiragana",
  "hiragana-iroha",
  "japanese-formal",
  "japanese-informal",
  "kannada",
  "katakana",
  "katakana-iroha",
  "khmer",
  "korean-hangul-formal",
  "korean-hanja-formal",
  "korean-hanja-informal",
  "lao",
  "lower-armenian",
  "malayalam",
  "mongolian",
  "myanmar",
  "oriya",
  "persian",
  "simp-chinese-formal",
  "simp-chinese-informal",
  "tamil",
  "telugu",
  "thai",
  "tibetan",
  "trad-chinese-formal",
  "trad-chinese-informal",
  "upper-armenian",
  "disclosure-open",
  "disclosure-closed",
  // Non-standard extensions (without prefixe)
  "ethiopic-halehame",
  "ethiopic-halehame-am",
  "ethiopic-halehame-ti-er",
  "ethiopic-halehame-ti-et",
  "hangul",
  "hangul-consonant",
  "urdu",
])
 
keywordSets.listStylePositionKeywords = uniteSets(keywordSets.basicKeywords, [
  "inside",
  "outside",
])
 
keywordSets.listStyleImageKeywords = uniteSets(keywordSets.basicKeywords, ["none"])
 
keywordSets.listStyleShorthandKeywords = uniteSets(
  keywordSets.basicKeywords,
  keywordSets.listStyleTypeKeywords,
  keywordSets.listStylePositionKeywords,
  keywordSets.listStyleImageKeywords
)
 
keywordSets.fontStyleKeywords = uniteSets(keywordSets.basicKeywords, [
  "normal",
  "italic",
  "oblique",
])
 
keywordSets.fontVariantKeywords = uniteSets(keywordSets.basicKeywords, [
  "normal",
  "none",
  "historical-forms",
  "none",
  "common-ligatures",
  "no-common-ligatures",
  "discretionary-ligatures",
  "no-discretionary-ligatures",
  "historical-ligatures",
  "no-historical-ligatures",
  "contextual",
  "no-contextual",
  "small-caps",
  "small-caps",
  "all-small-caps",
  "petite-caps",
  "all-petite-caps",
  "unicase",
  "titling-caps",
  "lining-nums",
  "oldstyle-nums",
  "proportional-nums",
  "tabular-nums",
  "diagonal-fractions",
  "stacked-fractions",
  "ordinal",
  "slashed-zero",
  "jis78",
  "jis83",
  "jis90",
  "jis04",
  "simplified",
  "traditional",
  "full-width",
  "proportional-width",
  "ruby",
])
 
keywordSets.fontStretchKeywords = uniteSets(keywordSets.basicKeywords, [
  "semi-condensed",
  "condensed",
  "extra-condensed",
  "ultra-condensed",
  "semi-expanded",
  "expanded",
  "extra-expanded",
  "ultra-expanded",
])
 
keywordSets.fontSizeKeywords = uniteSets(keywordSets.basicKeywords, [
  "xx-small",
  "x-small",
  "small",
  "medium",
  "large",
  "x-large",
  "xx-large",
  "larger",
  "smaller",
])
 
keywordSets.lineHeightKeywords = uniteSets(keywordSets.basicKeywords, ["normal"])
 
keywordSets.fontShorthandKeywords = uniteSets(
  keywordSets.basicKeywords,
  keywordSets.fontStyleKeywords,
  keywordSets.fontVariantKeywords,
  keywordSets.fontWeightKeywords,
  keywordSets.fontStretchKeywords,
  keywordSets.fontSizeKeywords,
  keywordSets.lineHeightKeywords, keywordSets.fontFamilyKeywords
)
 
keywordSets.keyframeSelectorKeywords = new Set([
  "from",
  "to",
])
 
// https://developer.mozilla.org/en/docs/Web/CSS/At-rule
keywordSets.atRules = new Set([
  "apply",
  "annotation",
  "character-variant",
  "charset",
  "counter-style",
  "custom-media",
  "custom-selector",
  "document",
  "font-face",
  "font-feature-values",
  "import",
  "keyframes",
  "media",
  "namespace",
  "nest",
  "ornaments",
  "page",
  "styleset",
  "stylistic",
  "supports",
  "swash",
  "viewport",
])
 
// https://drafts.csswg.org/mediaqueries/#descdef-media-update
keywordSets.deprecatedMediaFeatureNames = new Set([
  "device-aspect-ratio",
  "device-height",
  "device-width",
  "max-device-aspect-ratio",
  "max-device-height",
  "max-device-width",
  "min-device-aspect-ratio",
  "min-device-height",
  "min-device-width",
])
 
// https://drafts.csswg.org/mediaqueries/#descdef-media-update
keywordSets.mediaFeatureNames = uniteSets(keywordSets.deprecatedMediaFeatureNames, [
  "any-hover",
  "any-pointer",
  "aspect-ratio",
  "color",
  "color-gamut",
  "color-index",
  "grid",
  "height",
  "hover",
  "max-aspect-ratio",
  "max-color",
  "max-color-index",
  "max-height",
  "max-monochrome",
  "max-resolution",
  "max-width",
  "min-aspect-ratio",
  "min-color",
  "min-color-index",
  "min-height",
  "min-monochrome",
  "min-resolution",
  "min-width",
  "monochrome",
  "orientation",
  "overflow-block",
  "overflow-inline",
  "pointer",
  "resolution",
  "scan",
  "scripting",
  "update",
  "width",
])
 
// https://www.w3.org/TR/CSS22/ui.html#system-colors
keywordSets.systemColors = new Set([
  "activeborder",
  "activecaption",
  "appworkspace",
  "background",
  "buttonface",
  "buttonhighlight",
  "buttonshadow",
  "buttontext",
  "captiontext",
  "graytext",
  "highlight",
  "highlighttext",
  "inactiveborder",
  "inactivecaption",
  "inactivecaptiontext",
  "infobackground",
  "infotext",
  "menu",
  "menutext",
  "scrollbar",
  "threeddarkshadow",
  "threedface",
  "threedhighlight",
  "threedlightshadow",
  "threedshadow",
  "window",
  "windowframe",
  "windowtext",
])
 
function uniteSets() {
  const sets = Array.from(arguments)
 
  return new Set(sets.reduce((result, set) => {
    return result.concat(_.toArray(set))
  }, []))
}
 
module.exports = keywordSets